home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / blkdev.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  22KB  |  729 lines
  1. #ifndef _LINUX_BLKDEV_H
  2. #define _LINUX_BLKDEV_H
  3.  
  4. #include <linux/config.h>
  5. #include <linux/major.h>
  6. #include <linux/genhd.h>
  7. #include <linux/list.h>
  8. #include <linux/timer.h>
  9. #include <linux/workqueue.h>
  10. #include <linux/pagemap.h>
  11. #include <linux/backing-dev.h>
  12. #include <linux/wait.h>
  13. #include <linux/mempool.h>
  14. #include <linux/bio.h>
  15. #include <linux/module.h>
  16. #include <linux/stringify.h>
  17.  
  18. #include <asm/scatterlist.h>
  19.  
  20. struct request_queue;
  21. typedef struct request_queue request_queue_t;
  22. struct elevator_queue;
  23. typedef struct elevator_queue elevator_t;
  24. struct request_pm_state;
  25.  
  26. #define BLKDEV_MIN_RQ    4
  27. #define BLKDEV_MAX_RQ    128    /* Default maximum */
  28.  
  29. /*
  30.  * This is the per-process anticipatory I/O scheduler state.
  31.  */
  32. struct as_io_context {
  33.     spinlock_t lock;
  34.  
  35.     void (*dtor)(struct as_io_context *aic); /* destructor */
  36.     void (*exit)(struct as_io_context *aic); /* called on task exit */
  37.  
  38.     unsigned long state;
  39.     atomic_t nr_queued; /* queued reads & sync writes */
  40.     atomic_t nr_dispatched; /* number of requests gone to the drivers */
  41.  
  42.     /* IO History tracking */
  43.     /* Thinktime */
  44.     unsigned long last_end_request;
  45.     unsigned long ttime_total;
  46.     unsigned long ttime_samples;
  47.     unsigned long ttime_mean;
  48.     /* Layout pattern */
  49.     unsigned int seek_samples;
  50.     sector_t last_request_pos;
  51.     u64 seek_total;
  52.     sector_t seek_mean;
  53. };
  54.  
  55. struct cfq_queue;
  56. struct cfq_io_context {
  57.     void (*dtor)(struct cfq_io_context *);
  58.     void (*exit)(struct cfq_io_context *);
  59.  
  60.     struct io_context *ioc;
  61.  
  62.     /*
  63.      * circular list of cfq_io_contexts belonging to a process io context
  64.      */
  65.     struct list_head list;
  66.     struct cfq_queue *cfqq;
  67. };
  68.  
  69. /*
  70.  * This is the per-process I/O subsystem state.  It is refcounted and
  71.  * kmalloc'ed. Currently all fields are modified in process io context
  72.  * (apart from the atomic refcount), so require no locking.
  73.  */
  74. struct io_context {
  75.     atomic_t refcount;
  76.     pid_t pid;
  77.  
  78.     /*
  79.      * For request batching
  80.      */
  81.     unsigned long last_waited; /* Time last woken after wait for request */
  82.     int nr_batch_requests;     /* Number of requests left in the batch */
  83.  
  84.     spinlock_t lock;
  85.  
  86.     struct as_io_context *aic;
  87.     struct cfq_io_context *cic;
  88. };
  89.  
  90. void put_io_context(struct io_context *ioc);
  91. void exit_io_context(void);
  92. struct io_context *get_io_context(int gfp_flags);
  93. void copy_io_context(struct io_context **pdst, struct io_context **psrc);
  94. void swap_io_context(struct io_context **ioc1, struct io_context **ioc2);
  95.  
  96. struct request_list {
  97.     int count[2];
  98.     int starved[2];
  99.     mempool_t *rq_pool;
  100.     wait_queue_head_t wait[2];
  101.     wait_queue_head_t drain;
  102. };
  103.  
  104. #define BLK_MAX_CDB    16
  105.  
  106. /*
  107.  * try to put the fields that are referenced together in the same cacheline
  108.  */
  109. struct request {
  110.     struct list_head queuelist; /* looking for ->queue? you must _not_
  111.                      * access it directly, use
  112.                      * blkdev_dequeue_request! */
  113.     unsigned long flags;        /* see REQ_ bits below */
  114.  
  115.     /* Maintain bio traversal state for part by part I/O submission.
  116.      * hard_* are block layer internals, no driver should touch them!
  117.      */
  118.  
  119.     sector_t sector;        /* next sector to submit */
  120.     unsigned long nr_sectors;    /* no. of sectors left to submit */
  121.     /* no. of sectors left to submit in the current segment */
  122.     unsigned int current_nr_sectors;
  123.  
  124.     sector_t hard_sector;        /* next sector to complete */
  125.     unsigned long hard_nr_sectors;    /* no. of sectors left to complete */
  126.     /* no. of sectors left to complete in the current segment */
  127.     unsigned int hard_cur_sectors;
  128.  
  129.     struct bio *bio;
  130.     struct bio *biotail;
  131.  
  132.     void *elevator_private;
  133.  
  134.     int rq_status;    /* should split this into a few status bits */
  135.     struct gendisk *rq_disk;
  136.     int errors;
  137.     unsigned long start_time;
  138.  
  139.     /* Number of scatter-gather DMA addr+len pairs after
  140.      * physical address coalescing is performed.
  141.      */
  142.     unsigned short nr_phys_segments;
  143.  
  144.     /* Number of scatter-gather addr+len pairs after
  145.      * physical and DMA remapping hardware coalescing is performed.
  146.      * This is the number of scatter-gather entries the driver
  147.      * will actually have to deal with after DMA mapping is done.
  148.      */
  149.     unsigned short nr_hw_segments;
  150.  
  151.     int tag;
  152.     char *buffer;
  153.  
  154.     int ref_count;
  155.     request_queue_t *q;
  156.     struct request_list *rl;
  157.  
  158.     struct completion *waiting;
  159.     void *special;
  160.  
  161.     /*
  162.      * when request is used as a packet command carrier
  163.      */
  164.     unsigned int cmd_len;
  165.     unsigned char cmd[BLK_MAX_CDB];
  166.  
  167.     unsigned int data_len;
  168.     void *data;
  169.  
  170.     unsigned int sense_len;
  171.     void *sense;
  172.  
  173.     unsigned int timeout;
  174.  
  175.     /*
  176.      * For Power Management requests
  177.      */
  178.     struct request_pm_state *pm;
  179. };
  180.  
  181. /*
  182.  * first three bits match BIO_RW* bits, important
  183.  */
  184. enum rq_flag_bits {
  185.     __REQ_RW,        /* not set, read. set, write */
  186.     __REQ_FAILFAST,        /* no low level driver retries */
  187.     __REQ_SOFTBARRIER,    /* may not be passed by ioscheduler */
  188.     __REQ_HARDBARRIER,    /* may not be passed by drive either */
  189.     __REQ_CMD,        /* is a regular fs rw request */
  190.     __REQ_NOMERGE,        /* don't touch this for merging */
  191.     __REQ_STARTED,        /* drive already may have started this one */
  192.     __REQ_DONTPREP,        /* don't call prep for this one */
  193.     __REQ_QUEUED,        /* uses queueing */
  194.     /*
  195.      * for ATA/ATAPI devices
  196.      */
  197.     __REQ_PC,        /* packet command (special) */
  198.     __REQ_BLOCK_PC,        /* queued down pc from block layer */
  199.     __REQ_SENSE,        /* sense retrival */
  200.  
  201.     __REQ_FAILED,        /* set if the request failed */
  202.     __REQ_QUIET,        /* don't worry about errors */
  203.     __REQ_SPECIAL,        /* driver suplied command */
  204.     __REQ_DRIVE_CMD,
  205.     __REQ_DRIVE_TASK,
  206.     __REQ_DRIVE_TASKFILE,
  207.     __REQ_PREEMPT,        /* set for "ide_preempt" requests */
  208.     __REQ_PM_SUSPEND,    /* suspend request */
  209.     __REQ_PM_RESUME,    /* resume request */
  210.     __REQ_PM_SHUTDOWN,    /* shutdown request */
  211.     __REQ_BAR_PREFLUSH,    /* barrier pre-flush done */
  212.     __REQ_BAR_POSTFLUSH,    /* barrier post-flush */
  213.     __REQ_NR_BITS,        /* stops here */
  214. };
  215.  
  216. #define REQ_RW        (1 << __REQ_RW)
  217. #define REQ_FAILFAST    (1 << __REQ_FAILFAST)
  218. #define REQ_SOFTBARRIER    (1 << __REQ_SOFTBARRIER)
  219. #define REQ_HARDBARRIER    (1 << __REQ_HARDBARRIER)
  220. #define REQ_CMD        (1 << __REQ_CMD)
  221. #define REQ_NOMERGE    (1 << __REQ_NOMERGE)
  222. #define REQ_STARTED    (1 << __REQ_STARTED)
  223. #define REQ_DONTPREP    (1 << __REQ_DONTPREP)
  224. #define REQ_QUEUED    (1 << __REQ_QUEUED)
  225. #define REQ_PC        (1 << __REQ_PC)
  226. #define REQ_BLOCK_PC    (1 << __REQ_BLOCK_PC)
  227. #define REQ_SENSE    (1 << __REQ_SENSE)
  228. #define REQ_FAILED    (1 << __REQ_FAILED)
  229. #define REQ_QUIET    (1 << __REQ_QUIET)
  230. #define REQ_SPECIAL    (1 << __REQ_SPECIAL)
  231. #define REQ_DRIVE_CMD    (1 << __REQ_DRIVE_CMD)
  232. #define REQ_DRIVE_TASK    (1 << __REQ_DRIVE_TASK)
  233. #define REQ_DRIVE_TASKFILE    (1 << __REQ_DRIVE_TASKFILE)
  234. #define REQ_PREEMPT    (1 << __REQ_PREEMPT)
  235. #define REQ_PM_SUSPEND    (1 << __REQ_PM_SUSPEND)
  236. #define REQ_PM_RESUME    (1 << __REQ_PM_RESUME)
  237. #define REQ_PM_SHUTDOWN    (1 << __REQ_PM_SHUTDOWN)
  238. #define REQ_BAR_PREFLUSH    (1 << __REQ_BAR_PREFLUSH)
  239. #define REQ_BAR_POSTFLUSH    (1 << __REQ_BAR_POSTFLUSH)
  240.  
  241. /*
  242.  * State information carried for REQ_PM_SUSPEND and REQ_PM_RESUME
  243.  * requests. Some step values could eventually be made generic.
  244.  */
  245. struct request_pm_state
  246. {
  247.     /* PM state machine step value, currently driver specific */
  248.     int    pm_step;
  249.     /* requested PM state value (S1, S2, S3, S4, ...) */
  250.     u32    pm_state;
  251.     void*    data;        /* for driver use */
  252. };
  253.  
  254. #include <linux/elevator.h>
  255.  
  256. typedef int (merge_request_fn) (request_queue_t *, struct request *,
  257.                 struct bio *);
  258. typedef int (merge_requests_fn) (request_queue_t *, struct request *,
  259.                  struct request *);
  260. typedef void (request_fn_proc) (request_queue_t *q);
  261. typedef int (make_request_fn) (request_queue_t *q, struct bio *bio);
  262. typedef int (prep_rq_fn) (request_queue_t *, struct request *);
  263. typedef void (unplug_fn) (request_queue_t *);
  264.  
  265. struct bio_vec;
  266. typedef int (merge_bvec_fn) (request_queue_t *, struct bio *, struct bio_vec *);
  267. typedef void (activity_fn) (void *data, int rw);
  268. typedef int (issue_flush_fn) (request_queue_t *, struct gendisk *, sector_t *);
  269.  
  270. enum blk_queue_state {
  271.     Queue_down,
  272.     Queue_up,
  273. };
  274.  
  275. #define BLK_TAGS_PER_LONG    (sizeof(unsigned long) * 8)
  276. #define BLK_TAGS_MASK        (BLK_TAGS_PER_LONG - 1)
  277.  
  278. struct blk_queue_tag {
  279.     struct request **tag_index;    /* map of busy tags */
  280.     unsigned long *tag_map;        /* bit map of free/busy tags */
  281.     struct list_head busy_list;    /* fifo list of busy tags */
  282.     int busy;            /* current depth */
  283.     int max_depth;            /* what we will send to device */
  284.     int real_max_depth;        /* what the array can hold */
  285.     atomic_t refcnt;        /* map can be shared */
  286. };
  287.  
  288. struct request_queue
  289. {
  290.     /*
  291.      * Together with queue_head for cacheline sharing
  292.      */
  293.     struct list_head    queue_head;
  294.     struct request        *last_merge;
  295.     elevator_t        *elevator;
  296.  
  297.     /*
  298.      * the queue request freelist, one for reads and one for writes
  299.      */
  300.     struct request_list    rq;
  301.  
  302.     request_fn_proc        *request_fn;
  303.     merge_request_fn    *back_merge_fn;
  304.     merge_request_fn    *front_merge_fn;
  305.     merge_requests_fn    *merge_requests_fn;
  306.     make_request_fn        *make_request_fn;
  307.     prep_rq_fn        *prep_rq_fn;
  308.     unplug_fn        *unplug_fn;
  309.     merge_bvec_fn        *merge_bvec_fn;
  310.     activity_fn        *activity_fn;
  311.     issue_flush_fn        *issue_flush_fn;
  312.  
  313.     /*
  314.      * Auto-unplugging state
  315.      */
  316.     struct timer_list    unplug_timer;
  317.     int            unplug_thresh;    /* After this many requests */
  318.     unsigned long        unplug_delay;    /* After this many jiffies */
  319.     struct work_struct    unplug_work;
  320.  
  321.     struct backing_dev_info    backing_dev_info;
  322.  
  323.     /*
  324.      * The queue owner gets to use this for whatever they like.
  325.      * ll_rw_blk doesn't touch it.
  326.      */
  327.     void            *queuedata;
  328.  
  329.     void            *activity_data;
  330.  
  331.     /*
  332.      * queue needs bounce pages for pages above this limit
  333.      */
  334.     unsigned long        bounce_pfn;
  335.     int            bounce_gfp;
  336.  
  337.     /*
  338.      * various queue flags, see QUEUE_* below
  339.      */
  340.     unsigned long        queue_flags;
  341.  
  342.     /*
  343.      * protects queue structures from reentrancy
  344.      */
  345.     spinlock_t        *queue_lock;
  346.  
  347.     /*
  348.      * queue kobject
  349.      */
  350.     struct kobject kobj;
  351.  
  352.     /*
  353.      * queue settings
  354.      */
  355.     unsigned long        nr_requests;    /* Max # of requests */
  356.     unsigned int        nr_congestion_on;
  357.     unsigned int        nr_congestion_off;
  358.     unsigned int        nr_batching;
  359.  
  360.     unsigned short        max_sectors;
  361.     unsigned short        max_hw_sectors;
  362.     unsigned short        max_phys_segments;
  363.     unsigned short        max_hw_segments;
  364.     unsigned short        hardsect_size;
  365.     unsigned int        max_segment_size;
  366.  
  367.     unsigned long        seg_boundary_mask;
  368.     unsigned int        dma_alignment;
  369.  
  370.     struct blk_queue_tag    *queue_tags;
  371.  
  372.     atomic_t        refcnt;
  373.  
  374.     unsigned int        in_flight;
  375.  
  376.     /*
  377.      * sg stuff
  378.      */
  379.     unsigned int        sg_timeout;
  380.     unsigned int        sg_reserved_size;
  381.  
  382.     struct list_head    drain_list;
  383. };
  384.  
  385. #define RQ_INACTIVE        (-1)
  386. #define RQ_ACTIVE        1
  387. #define RQ_SCSI_BUSY        0xffff
  388. #define RQ_SCSI_DONE        0xfffe
  389. #define RQ_SCSI_DISCONNECTING    0xffe0
  390.  
  391. #define QUEUE_FLAG_CLUSTER    0    /* cluster several segments into 1 */
  392. #define QUEUE_FLAG_QUEUED    1    /* uses generic tag queueing */
  393. #define QUEUE_FLAG_STOPPED    2    /* queue is stopped */
  394. #define    QUEUE_FLAG_READFULL    3    /* write queue has been filled */
  395. #define QUEUE_FLAG_WRITEFULL    4    /* read queue has been filled */
  396. #define QUEUE_FLAG_DEAD        5    /* queue being torn down */
  397. #define QUEUE_FLAG_REENTER    6    /* Re-entrancy avoidance */
  398. #define QUEUE_FLAG_PLUGGED    7    /* queue is plugged */
  399. #define QUEUE_FLAG_ORDERED    8    /* supports ordered writes */
  400. #define QUEUE_FLAG_DRAIN    9    /* draining queue for sched switch */
  401.  
  402. #define blk_queue_plugged(q)    test_bit(QUEUE_FLAG_PLUGGED, &(q)->queue_flags)
  403. #define blk_queue_tagged(q)    test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
  404. #define blk_queue_stopped(q)    test_bit(QUEUE_FLAG_STOPPED, &(q)->queue_flags)
  405.  
  406. #define blk_fs_request(rq)    ((rq)->flags & REQ_CMD)
  407. #define blk_pc_request(rq)    ((rq)->flags & REQ_BLOCK_PC)
  408. #define blk_noretry_request(rq)    ((rq)->flags & REQ_FAILFAST)
  409. #define blk_rq_started(rq)    ((rq)->flags & REQ_STARTED)
  410.  
  411. #define blk_account_rq(rq)    (blk_rq_started(rq) && blk_fs_request(rq))
  412.  
  413. #define blk_pm_suspend_request(rq)    ((rq)->flags & REQ_PM_SUSPEND)
  414. #define blk_pm_resume_request(rq)    ((rq)->flags & REQ_PM_RESUME)
  415. #define blk_pm_request(rq)    \
  416.     ((rq)->flags & (REQ_PM_SUSPEND | REQ_PM_RESUME))
  417.  
  418. #define blk_barrier_rq(rq)    ((rq)->flags & REQ_HARDBARRIER)
  419. #define blk_barrier_preflush(rq)    ((rq)->flags & REQ_BAR_PREFLUSH)
  420. #define blk_barrier_postflush(rq)    ((rq)->flags & REQ_BAR_POSTFLUSH)
  421.  
  422. #define list_entry_rq(ptr)    list_entry((ptr), struct request, queuelist)
  423.  
  424. #define rq_data_dir(rq)        ((rq)->flags & 1)
  425.  
  426. static inline int blk_queue_full(struct request_queue *q, int rw)
  427. {
  428.     if (rw == READ)
  429.         return test_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  430.     return test_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  431. }
  432.  
  433. static inline void blk_set_queue_full(struct request_queue *q, int rw)
  434. {
  435.     if (rw == READ)
  436.         set_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  437.     else
  438.         set_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  439. }
  440.  
  441. static inline void blk_clear_queue_full(struct request_queue *q, int rw)
  442. {
  443.     if (rw == READ)
  444.         clear_bit(QUEUE_FLAG_READFULL, &q->queue_flags);
  445.     else
  446.         clear_bit(QUEUE_FLAG_WRITEFULL, &q->queue_flags);
  447. }
  448.  
  449.  
  450. /*
  451.  * mergeable request must not have _NOMERGE or _BARRIER bit set, nor may
  452.  * it already be started by driver.
  453.  */
  454. #define RQ_NOMERGE_FLAGS    \
  455.     (REQ_NOMERGE | REQ_STARTED | REQ_HARDBARRIER | REQ_SOFTBARRIER)
  456. #define rq_mergeable(rq)    \
  457.     (!((rq)->flags & RQ_NOMERGE_FLAGS) && blk_fs_request((rq)))
  458.  
  459. /*
  460.  * noop, requests are automagically marked as active/inactive by I/O
  461.  * scheduler -- see elv_next_request
  462.  */
  463. #define blk_queue_headactive(q, head_active)
  464.  
  465. /*
  466.  * q->prep_rq_fn return values
  467.  */
  468. #define BLKPREP_OK        0    /* serve it */
  469. #define BLKPREP_KILL        1    /* fatal error, kill */
  470. #define BLKPREP_DEFER        2    /* leave on queue */
  471.  
  472. extern unsigned long blk_max_low_pfn, blk_max_pfn;
  473.  
  474. /*
  475.  * standard bounce addresses:
  476.  *
  477.  * BLK_BOUNCE_HIGH    : bounce all highmem pages
  478.  * BLK_BOUNCE_ANY    : don't bounce anything
  479.  * BLK_BOUNCE_ISA    : bounce pages above ISA DMA boundary
  480.  */
  481. #define BLK_BOUNCE_HIGH        ((u64)blk_max_low_pfn << PAGE_SHIFT)
  482. #define BLK_BOUNCE_ANY        ((u64)blk_max_pfn << PAGE_SHIFT)
  483. #define BLK_BOUNCE_ISA        (ISA_DMA_THRESHOLD)
  484.  
  485. #ifdef CONFIG_MMU
  486. extern int init_emergency_isa_pool(void);
  487. extern void blk_queue_bounce(request_queue_t *q, struct bio **bio);
  488. #else
  489. static inline int init_emergency_isa_pool(void)
  490. {
  491.     return 0;
  492. }
  493. static inline void blk_queue_bounce(request_queue_t *q, struct bio **bio)
  494. {
  495. }
  496. #endif /* CONFIG_MMU */
  497.  
  498. #define rq_for_each_bio(_bio, rq)    \
  499.     if ((rq->bio))            \
  500.         for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)
  501.  
  502. struct sec_size {
  503.     unsigned block_size;
  504.     unsigned block_size_bits;
  505. };
  506.  
  507. extern int blk_register_queue(struct gendisk *disk);
  508. extern void blk_unregister_queue(struct gendisk *disk);
  509. extern void register_disk(struct gendisk *dev);
  510. extern void generic_make_request(struct bio *bio);
  511. extern void blk_put_request(struct request *);
  512. extern void blk_attempt_remerge(request_queue_t *, struct request *);
  513. extern void __blk_attempt_remerge(request_queue_t *, struct request *);
  514. extern struct request *blk_get_request(request_queue_t *, int, int);
  515. extern void blk_put_request(struct request *);
  516. extern void blk_insert_request(request_queue_t *, struct request *, int, void *, int);
  517. extern void blk_requeue_request(request_queue_t *, struct request *);
  518. extern void blk_plug_device(request_queue_t *);
  519. extern int blk_remove_plug(request_queue_t *);
  520. extern void blk_recount_segments(request_queue_t *, struct bio *);
  521. extern int blk_phys_contig_segment(request_queue_t *q, struct bio *, struct bio *);
  522. extern int blk_hw_contig_segment(request_queue_t *q, struct bio *, struct bio *);
  523. extern int scsi_cmd_ioctl(struct file *, struct gendisk *, unsigned int, void __user *);
  524. extern void blk_start_queue(request_queue_t *q);
  525. extern void blk_stop_queue(request_queue_t *q);
  526. extern void blk_sync_queue(struct request_queue *q);
  527. extern void __blk_stop_queue(request_queue_t *q);
  528. extern void blk_run_queue(request_queue_t *);
  529. extern void blk_queue_activity_fn(request_queue_t *, activity_fn *, void *);
  530. extern struct request *blk_rq_map_user(request_queue_t *, int, void __user *, unsigned int);
  531. extern int blk_rq_unmap_user(struct request *, struct bio *, unsigned int);
  532. extern int blk_execute_rq(request_queue_t *, struct gendisk *, struct request *);
  533.  
  534. static inline request_queue_t *bdev_get_queue(struct block_device *bdev)
  535. {
  536.     return bdev->bd_disk->queue;
  537. }
  538.  
  539. static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
  540.                        struct page *page)
  541. {
  542.     if (bdi && bdi->unplug_io_fn)
  543.         bdi->unplug_io_fn(bdi, page);
  544. }
  545.  
  546. static inline void blk_run_address_space(struct address_space *mapping)
  547. {
  548.     if (mapping)
  549.         blk_run_backing_dev(mapping->backing_dev_info, NULL);
  550. }
  551.  
  552. /*
  553.  * end_request() and friends. Must be called with the request queue spinlock
  554.  * acquired. All functions called within end_request() _must_be_ atomic.
  555.  *
  556.  * Several drivers define their own end_request and call
  557.  * end_that_request_first() and end_that_request_last()
  558.  * for parts of the original function. This prevents
  559.  * code duplication in drivers.
  560.  */
  561. extern int end_that_request_first(struct request *, int, int);
  562. extern int end_that_request_chunk(struct request *, int, int);
  563. extern void end_that_request_last(struct request *);
  564. extern void end_request(struct request *req, int uptodate);
  565.  
  566. /*
  567.  * end_that_request_first/chunk() takes an uptodate argument. we account
  568.  * any value <= as an io error. 0 means -EIO for compatability reasons,
  569.  * any other < 0 value is the direct error type. An uptodate value of
  570.  * 1 indicates successful io completion
  571.  */
  572. #define end_io_error(uptodate)    (unlikely((uptodate) <= 0))
  573.  
  574. static inline void blkdev_dequeue_request(struct request *req)
  575. {
  576.     BUG_ON(list_empty(&req->queuelist));
  577.  
  578.     list_del_init(&req->queuelist);
  579.  
  580.     if (req->rl)
  581.         elv_remove_request(req->q, req);
  582. }
  583.  
  584. /*
  585.  * Access functions for manipulating queue properties
  586.  */
  587. extern request_queue_t *blk_init_queue(request_fn_proc *, spinlock_t *);
  588. extern void blk_cleanup_queue(request_queue_t *);
  589. extern void blk_queue_make_request(request_queue_t *, make_request_fn *);
  590. extern void blk_queue_bounce_limit(request_queue_t *, u64);
  591. extern void blk_queue_max_sectors(request_queue_t *, unsigned short);
  592. extern void blk_queue_max_phys_segments(request_queue_t *, unsigned short);
  593. extern void blk_queue_max_hw_segments(request_queue_t *, unsigned short);
  594. extern void blk_queue_max_segment_size(request_queue_t *, unsigned int);
  595. extern void blk_queue_hardsect_size(request_queue_t *, unsigned short);
  596. extern void blk_queue_stack_limits(request_queue_t *t, request_queue_t *b);
  597. extern void blk_queue_segment_boundary(request_queue_t *, unsigned long);
  598. extern void blk_queue_prep_rq(request_queue_t *, prep_rq_fn *pfn);
  599. extern void blk_queue_merge_bvec(request_queue_t *, merge_bvec_fn *);
  600. extern void blk_queue_dma_alignment(request_queue_t *, int);
  601. extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
  602. extern void blk_queue_ordered(request_queue_t *, int);
  603. extern void blk_queue_issue_flush_fn(request_queue_t *, issue_flush_fn *);
  604. extern int blkdev_scsi_issue_flush_fn(request_queue_t *, struct gendisk *, sector_t *);
  605.  
  606. extern int blk_rq_map_sg(request_queue_t *, struct request *, struct scatterlist *);
  607. extern void blk_dump_rq_flags(struct request *, char *);
  608. extern void generic_unplug_device(request_queue_t *);
  609. extern void __generic_unplug_device(request_queue_t *);
  610. extern long nr_blockdev_pages(void);
  611. extern void blk_wait_queue_drained(request_queue_t *, int);
  612. extern void blk_finish_queue_drain(request_queue_t *);
  613.  
  614. int blk_get_queue(request_queue_t *);
  615. request_queue_t *blk_alloc_queue(int);
  616. #define blk_put_queue(q) blk_cleanup_queue((q))
  617.  
  618. /*
  619.  * tag stuff
  620.  */
  621. #define blk_queue_tag_depth(q)        ((q)->queue_tags->busy)
  622. #define blk_queue_tag_queue(q)        ((q)->queue_tags->busy < (q)->queue_tags->max_depth)
  623. #define blk_rq_tagged(rq)        ((rq)->flags & REQ_QUEUED)
  624. extern int blk_queue_start_tag(request_queue_t *, struct request *);
  625. extern struct request *blk_queue_find_tag(request_queue_t *, int);
  626. extern void blk_queue_end_tag(request_queue_t *, struct request *);
  627. extern int blk_queue_init_tags(request_queue_t *, int, struct blk_queue_tag *);
  628. extern void blk_queue_free_tags(request_queue_t *);
  629. extern int blk_queue_resize_tags(request_queue_t *, int);
  630. extern void blk_queue_invalidate_tags(request_queue_t *);
  631. extern long blk_congestion_wait(int rw, long timeout);
  632.  
  633. extern void blk_rq_bio_prep(request_queue_t *, struct request *, struct bio *);
  634. extern int blkdev_issue_flush(struct block_device *, sector_t *);
  635.  
  636. #define MAX_PHYS_SEGMENTS 128
  637. #define MAX_HW_SEGMENTS 128
  638. #define MAX_SECTORS 255
  639.  
  640. #define MAX_SEGMENT_SIZE    65536
  641.  
  642. #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
  643.  
  644. extern void drive_stat_acct(struct request *, int, int);
  645.  
  646. static inline int queue_hardsect_size(request_queue_t *q)
  647. {
  648.     int retval = 512;
  649.  
  650.     if (q && q->hardsect_size)
  651.         retval = q->hardsect_size;
  652.  
  653.     return retval;
  654. }
  655.  
  656. static inline int bdev_hardsect_size(struct block_device *bdev)
  657. {
  658.     return queue_hardsect_size(bdev_get_queue(bdev));
  659. }
  660.  
  661. static inline int queue_dma_alignment(request_queue_t *q)
  662. {
  663.     int retval = 511;
  664.  
  665.     if (q && q->dma_alignment)
  666.         retval = q->dma_alignment;
  667.  
  668.     return retval;
  669. }
  670.  
  671. static inline int bdev_dma_aligment(struct block_device *bdev)
  672. {
  673.     return queue_dma_alignment(bdev_get_queue(bdev));
  674. }
  675.  
  676. #define blk_finished_io(nsects)    do { } while (0)
  677. #define blk_started_io(nsects)    do { } while (0)
  678.  
  679. /* assumes size > 256 */
  680. static inline unsigned int blksize_bits(unsigned int size)
  681. {
  682.     unsigned int bits = 8;
  683.     do {
  684.         bits++;
  685.         size >>= 1;
  686.     } while (size > 256);
  687.     return bits;
  688. }
  689.  
  690. extern inline unsigned int block_size(struct block_device *bdev)
  691. {
  692.     return bdev->bd_block_size;
  693. }
  694.  
  695. typedef struct {struct page *v;} Sector;
  696.  
  697. unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
  698.  
  699. static inline void put_dev_sector(Sector p)
  700. {
  701.     page_cache_release(p.v);
  702. }
  703.  
  704. struct work_struct;
  705. int kblockd_schedule_work(struct work_struct *work);
  706. void kblockd_flush(void);
  707.  
  708. #ifdef CONFIG_LBD
  709. # include <asm/div64.h>
  710. # define sector_div(a, b) do_div(a, b)
  711. #else
  712. # define sector_div(n, b)( \
  713. { \
  714.     int _res; \
  715.     _res = (n) % (b); \
  716.     (n) /= (b); \
  717.     _res; \
  718. } \
  719. )
  720. #endif 
  721.  
  722. #define MODULE_ALIAS_BLOCKDEV(major,minor) \
  723.     MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
  724. #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
  725.     MODULE_ALIAS("block-major-" __stringify(major) "-*")
  726.  
  727.  
  728. #endif
  729.